package day5

import "fmt"

/*
只要一个变量，含有接口类型中的所有方法，那么这个变量就实现这个接口。
如果一个变量含有了多个interface类型的方法，那么这个变量就实现了多个接口。
*/
type MyInterface interface{
	GetName() string
	GetAge() int
}

type StringInterface interface{
	SumAgeSa() int
}

type CommonInterface interface{
	MyInterface
	StringInterface
	GetGender() string
}

type Employee struct {
	name   string
	age    int
	salary int
	gender string
}

func (self *Employee) GetName() string {
	return self.name
}

func (self *Employee) GetAge() int {
	return self.age
}

func (self *Employee) SumAgeSa() int {
	return self.age + self.salary
}

func (self *Employee) GetGender() string {
	return self.gender
}

/*放在同一个包下自动关联上了*/
func IntRun()  {
	// 空接口的使用，空接口类型的变量可以保存任何类型的值
	// 空格口类型的变量非常类似于弱类型语言中的变量
	var varEmptyInterface interface{}
	fmt.Println("varEmptyInterface is of type %T\n", varEmptyInterface)
	varEmptyInterface = 100
	y := varEmptyInterface.(int) //这里可以类型转换（类型断言 ）
	fmt.Println("varEmptyInterface is of type int", varEmptyInterface, y)
	varEmptyInterface = "Golang"
	k, err := varEmptyInterface.(string) //待判断的类型转换（类型断言 ）
	if err {
		fmt.Println("varEmptyInterface is of type string", varEmptyInterface, k)
	}
	classifier(varEmptyInterface)

	varEmployee := Employee{
		name:   "Jack Ma",
		age:    50,
		salary: 100000000,
		gender: "Male",
	}

	var mm MyInterface = &varEmployee
	fmt.Println(mm.GetName())
	fmt.Println(mm.GetAge())

	//这里可以调用组合内的所有接口
	var ww CommonInterface = &varEmployee
	fmt.Println(ww.GetAge(), ww.GetGender(), ww.GetName(), ww.SumAgeSa())
}

/*
通过类型获取值
*/
func classifier(items ...interface{}) {
	for i, x := range items {
		switch x.(type) {
		case bool:
			fmt.Println("classifier", "bool", i, x)
		case float64:
			fmt.Println("classifier","float64", i, x)
		case int, int64:
			fmt.Println("classifier","int", i, x)
		case nil:
			fmt.Println("classifier","nil", i, x)
		case string:
			fmt.Println("classifier","string", i, x)
		default:
			fmt.Println("classifier","other", i, x)
		}
	}
}



